package com.hama.iotrust.common.mybatis.criteria;

import com.hama.iotrust.common.mybatis.criteria.BetweenExpression;
import com.hama.iotrust.common.mybatis.criteria.Expression;
import com.hama.iotrust.common.mybatis.criteria.InExpression;
import com.hama.iotrust.common.mybatis.criteria.LikeExpression;
import com.hama.iotrust.common.mybatis.criteria.LogicExpression;
import com.hama.iotrust.common.mybatis.criteria.NotInExpression;
import com.hama.iotrust.common.mybatis.criteria.NotNullExpression;
import com.hama.iotrust.common.mybatis.criteria.NullExpression;
import com.hama.iotrust.common.mybatis.criteria.SimpleExpression;
import com.hama.iotrust.common.mybatis.criteria.SqlExpression;

/**
 * A factory for creating Expression objects.
 * 
 * @author 金建强(ptma@163.com)
 * @version 1.0.0
 * @since 2013-4-2 11:23:16
 */
public class ExpressionFactory {

    /**
     * 逻辑与
     * 
     * @param lhp 左表达式
     * @param rhp 右表达式
     * @return LogicExpression 逻辑表达式
     */
    public static LogicExpression and(Expression lhp, Expression rhp) {
        return new LogicExpression(lhp, LogicExpression.Operator.AND, rhp);
    }

    /**
     * 逻辑或
     * 
     * @param lhp 左表达式
     * @param rhp 右表达式
     * @return LogicExpression 逻辑表达式
     */
    public static LogicExpression or(Expression lhp, Expression rhp) {
        return new LogicExpression(lhp, LogicExpression.Operator.OR, rhp);
    }

    /**
     * 小于
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return SimpleExpression 基本表达式
     */
    public static SimpleExpression lessThan(String propertyName, Object value) {
        return new SimpleExpression(propertyName, SimpleExpression.Operator.LessThen, value);
    }

    /**
     * 大于
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return SimpleExpression 基本表达式
     */
    public static SimpleExpression greaterThan(String propertyName, Object value) {
        return new SimpleExpression(propertyName, SimpleExpression.Operator.GreaterThen, value);
    }

    /**
     * 小于等于
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return SimpleExpression 基本表达式
     */
    public static SimpleExpression lessEqual(String propertyName, Object value) {
        return new SimpleExpression(propertyName, SimpleExpression.Operator.LessEqual, value);
    }

    /**
     * 大于等于
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return SimpleExpression 基本表达式
     */
    public static SimpleExpression greaterEqual(String propertyName, Object value) {
        return new SimpleExpression(propertyName, SimpleExpression.Operator.GreaterEqual, value);
    }

    /**
     * 等于
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return SimpleExpression 基本表达式
     */
    public static SimpleExpression eq(String propertyName, Object value) {
        return new SimpleExpression(propertyName, SimpleExpression.Operator.Equal, value);
    }

    /**
     * 不等于
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return SimpleExpression 基本表达式
     */
    public static SimpleExpression notEq(String propertyName, Object value) {
        return new SimpleExpression(propertyName, SimpleExpression.Operator.NotEqual, value);
    }

    /**
     * LIKE
     * 
     * @param propertyName 表达式属性名
     * @param value 表达式值
     * @return LikeExpression LIKE表达式
     */
    public static LikeExpression like(String propertyName, String value) {
        return new LikeExpression(propertyName, value);
    }

    /**
     * 为空
     * 
     * @param propertyName 表达式属性名
     * @return NullExpression NULL表达式
     */
    public static NullExpression isNull(String propertyName) {
        return new NullExpression(propertyName);
    }

    /**
     * 不为空
     * 
     * @param propertyName 表达式属性名
     * @return NotNullExpression NOT NULL表达式
     */
    public static NotNullExpression isNotNull(String propertyName) {
        return new NotNullExpression(propertyName);
    }

    /**
     * IN
     * 
     * @param propertyName 表达式属性名
     * @param values 表达式值数组
     * @return InExpression
     */
    public static InExpression in(String propertyName, Object... values) {
        return new InExpression(propertyName, values);
    }

    /**
     * NOT IN
     * 
     * @param propertyName 表达式属性名
     * @param values 表达式值数组
     * @return NotInExpression
     */
    public static NotInExpression notIn(String propertyName, Object... values) {
        return new NotInExpression(propertyName, values);
    }

    /**
     * Between
     * 
     * @param propertyName 表达式属性名
     * @param value1 值1
     * @param value2 值2
     * @return BetweenExpression
     */
    public static BetweenExpression between(String propertyName, Object value1, Object value2) {
        return new BetweenExpression(propertyName, value1, value2);
    }

    /**
     * 原始 Sql
     * 
     * @param sql 原始SQL表达式
     * @return SqlExpression
     */
    public static SqlExpression sql(String sql) {
        return new SqlExpression(sql);
    }
}
